/*++

Module Name:

    nvrio.c

Abstract:

    Access function to r/w environment variables from NVRAM

Author:

    Mudit Vats (v-muditv) 12-13-99

Revision History:

--*/
#include <precomp.h>

#define FIELD_OFFSET(type, field)    ((UINT32)(UINTN)&(((type *)0)->field))

#define ALIGN_DOWN(length, type) \
    ((UINT32)(length) & ~(sizeof(type) - 1))

#define ALIGN_UP(length, type) \
    (ALIGN_DOWN(((UINT32)(length) + sizeof(type) - 1), type))

#define EFI_ATTR     EFI_VARIABLE_NON_VOLATILE  | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS

#if !defined(_WIN64)
typedef unsigned long    ULONG_PTR, *PULONG_PTR;
#else
typedef unsigned __int64 ULONG_PTR, *PULONG_PTR;
#endif

#ifndef POINTER_IS_ALIGNED
// BOOL
// POINTER_IS_ALIGNED(
//     IN LPVOID Ptr,
//     IN DWORD Pow2      // undefined if this isn't a power of 2.
//     );
//
#define POINTER_IS_ALIGNED(Ptr,Pow2) \
        ( ( ( ((ULONG_PTR)(Ptr)) & (((Pow2)-1)) ) == 0) ? TRUE : FALSE )
#endif // !POINTER_IS_ALIGNED

VOID*  LoadOptions     [MAXBOOTVARS];
UINT64 LoadOptionsSize [MAXBOOTVARS];

VOID* BootOrder;
UINT64 BootOrderCount;
UINT64 OsBootOptionCount;

#define LOAD_OPTION_ACTIVE            0x00000001

//
// local routines
//
BOOLEAN
SetBootManagerVar(
                UINTN    BootVarNum
                );

BOOLEAN
SetBootManagerVarCheck(
                UINTN    BootVarNum
                );



INT32
SafeWcslen (
           CHAR16 *String,
           CHAR16 *Max
           )
{
    CHAR16 *p = String;
    while ( (p < Max) && (*p != 0) ) {
        p++;
    }

    if ( p < Max ) {
        return(UINT32)(p - String);
    }

    return -1;

} // SafeWclen

#define ISWINDOWSOSCHECK_DEBUG 0


BOOLEAN
isWindowsOsBootOption(
    char*       elo, 
    UINT64      eloSize
    )
//
// Purpose:     determine if the EFI_LOAD_OPTION structure in question is referring to 
//              a Windows OS boot option
// 
// Return:
// 
//      TRUE    elo refers to a Windows OS option
//
{
    CHAR16              *max;
    INT32               l;
    UINTN               length;
    PEFI_LOAD_OPTION    pElo;
    char*               devicePath;
    char*               osOptions;
    PWINDOWS_OS_OPTIONS pOsOptions;
    char*               aOsOptions;
    BOOLEAN             status;

    status = TRUE;
    aOsOptions = NULL;

    pElo = (EFI_LOAD_OPTION*)elo;

    if ( eloSize < sizeof(EFI_LOAD_OPTION) ) {
        status = FALSE;
        goto Done;
    }    

#if ISWINDOWSOSCHECK_DEBUG
    Print( L"Is %s a Windows OS boot option?\n", pElo->Description );
#endif

    //
    // Is the description properly terminated?
    //

    max = (CHAR16 *)(elo + eloSize);
    
    l = SafeWcslen( pElo->Description, max );
    if ( l < 0 ) {
#if ISWINDOWSOSCHECK_DEBUG
        Print (L"Failed: SafeWcslen( pElo->Description, max )\n");
#endif        
        status = FALSE;
        goto Done;
    }

    //
    // get the WINDOWS_OS_OPTIONS structure from the OptionalData field
    //
    
    osOptions = elo + 
                    FIELD_OFFSET(EFI_LOAD_OPTION,Description) +
                    StrSize(pElo->Description) +
                    pElo->FilePathListLength;
    
    length = (UINTN)eloSize;
    length -= (UINTN)(osOptions - elo);
    
#if ISWINDOWSOSCHECK_DEBUG
    Print (L"length = %x\n", length);
#endif

    //
    // make sure osOptions are atleast the size of the 
    // WINDOWS_OS_OPTIONS header
    // 
    //

    if ( length < FIELD_OFFSET(WINDOWS_OS_OPTIONS, OsLoadOptions) ) {
#if ISWINDOWSOSCHECK_DEBUG
        Print (L"Failed: invalid length: %x\n", length);
#endif
        status = FALSE;
        goto Done;
    }

    //
    // align the os options
    //
    
    aOsOptions = GetAlignedOsOptions(elo, eloSize);
    pOsOptions = (WINDOWS_OS_OPTIONS*)aOsOptions;

#if ISWINDOWSOSCHECK_DEBUG
    DisplayOsOptions(aOsOptions);
#endif

    //
    // Does the OsOptions structure look like a WINDOWS_OS_OPTIONS structure?
    //
    
    if ( (length != pOsOptions->Length) ||
         (WINDOWS_OS_OPTIONS_VERSION != pOsOptions->Version) ||
         (strcmpa(pOsOptions->Signature, WINDOWS_OS_OPTIONS_SIGNATURE) != 0) ) {
#if ISWINDOWSOSCHECK_DEBUG
        Print (L"Failed: OsOptions doesn't look like WINDOWS_OS_OPTIONS structure.\n");
        Print (L"test1: %x\n", length != pOsOptions->Length);
        Print (L"test2: %x\n", WINDOWS_OS_OPTIONS_VERSION != pOsOptions->Version);
        Print (L"test3: %x\n", strcmpa(pOsOptions->Signature, WINDOWS_OS_OPTIONS_SIGNATURE) != 0 );
#endif        
        status = FALSE;
        goto Done;
    }
    
    //
    // Is the OsLoadOptions string properly terminated?
    //
    
    //
    // create a new max ptr to accomodate the fact that we are
    // now using an aligned copy of OsOptions from the Pool
    //
    max = (CHAR16*)(aOsOptions + pOsOptions->Length);

#if ISWINDOWSOSCHECK_DEBUG
    Print (L"max = %x, osloadoptions = %x, diff = %x, strsize=%x\n", 
           max, 
           pOsOptions->OsLoadOptions,
           (char*)max - (char*)pOsOptions->OsLoadOptions,
           StrSize(pOsOptions->OsLoadOptions)
           );
#endif    
    
    l = SafeWcslen( pOsOptions->OsLoadOptions, max );
    if ( l < 0 ) {
#if ISWINDOWSOSCHECK_DEBUG
        Print (L"Failed: SafeWcslen( osLoadOptions, max ) = %x\n", l);
#endif        
        status = FALSE;
        goto Done;
    }

Done:
    
    //
    // we are done with the os options
    //
    
    if (aOsOptions != NULL) {
        FreePool(aOsOptions);
    }

    return status;
}

#define GETBOOTVARS_DEBUG GLOBAL_DEBUG

VOID
GetBootManagerVars(
                  )
{
    UINT32 i,j;
    CHAR16 szTemp[10];
    VOID* bootvar;
    UINT64 BootOrderSize = 0;
    UINT64 maxBootCount;

    //
    // Initialize EFI LoadOptions.
    //
    BootOrderSize = 0;
    BootOrderCount = 0;
    OsBootOptionCount = 0;
    BootOrder = NULL;

#if 1
    ZeroMem( LoadOptions, sizeof(VOID*) * MAXBOOTVARS );
    ZeroMem( LoadOptionsSize, sizeof(UINT64) * MAXBOOTVARS );
#endif

    //
    // Ensure that the Load Options have been freed
    //
    ASSERT(BootOrderCount == 0);

    //
    // Get BootOrder.
    //
    BootOrder = LibGetVariableAndSize( L"BootOrder", &VenEfi, &BootOrderSize );

    if ( BootOrder ) {

        BootOrderCount = BootOrderSize / sizeof(CHAR16);

#if GETBOOTVARS_DEBUG
        Print (L"BootOrderCount = %x\n", BootOrderCount);
#endif

        maxBootCount = (MAXBOOTVARS < BootOrderCount) ? MAXBOOTVARS : BootOrderCount;
        //
        // Get the boot options.
        //
        for ( i=0; i<maxBootCount; i++ ) {
            SPrint( szTemp, sizeof(szTemp), L"Boot%04x", ((CHAR16*) BootOrder)[i] );

            ASSERT(LoadOptions[i] == NULL);
            ASSERT(LoadOptionsSize[i] == 0);

            LoadOptions[i] = LibGetVariableAndSize( szTemp, &VenEfi, &(LoadOptionsSize[i]) );

            //
            // The NVRAM variables are case sensitive.  The boot order variable said this
            // entry should exist.  If we did not find it, try again with uppercase
            // hexadecimal string
            //
            if (LoadOptions[i] == NULL && LoadOptionsSize[i] == 0) {
                SPrint( szTemp, sizeof(szTemp), L"Boot%04X", ((CHAR16*) BootOrder)[i] );
            
                LoadOptions[i] = LibGetVariableAndSize( szTemp, &VenEfi, &(LoadOptionsSize[i]) );
            }

#if GETBOOTVARS_DEBUG
            Print (L"i = %x, szTemp = %s, BOCnt = %x, LOptions = %x, BSize = %x\n", 
                   i,
                   szTemp,
                   OsBootOptionCount,
                   LoadOptions[i],
                   LoadOptionsSize[i]
                   );
#endif            
            

            OsBootOptionCount++;
        }
    }
#if GETBOOTVARS_DEBUG
    Print(L"BootOrderCount: %d OsBootOptionCount: %d\n", BootOrderCount, OsBootOptionCount);
#endif
}


#define ERASEBOOTOPT_DEBUG GLOBAL_DEBUG

BOOLEAN
EraseOsBootOption(
                    UINTN       BootVarNum
                  )
{
    UINTN   j;
    CHAR16  szTemp[10];
    CHAR16* tmpBootOrder;
    VOID*   bootvar;
    UINT64  BootOrderSize = 0;
    VOID*   pDummy;
    UINTN   dummySize;

    //
    // validate BootVarNum
    //
    if (MAXBOOTVARS <= BootVarNum) {
        return FALSE;
    }

    //
    // Initialize EFI LoadOptions.
    //
    BootOrderSize = 0;
    BootOrderCount = 0;
    BootOrder = NULL;

    //
    // Get BootOrder.
    //
    BootOrder = LibGetVariableAndSize( L"BootOrder", &VenEfi, &BootOrderSize );

    BootOrderCount = BootOrderSize / sizeof(CHAR16);

    ASSERT(BootVarNum < MAXBOOTVARS);
    ASSERT(BootOrderCount >= 1);
    
#if ERASEBOOTOPT_DEBUG
    Print (L"BootOrderCount = %x\n", BootOrderCount);
    Print (L"BootVarNum = %x\n", BootVarNum);
#endif

    //
    // if the boot option is populated, then erase it
    //
    if (LoadOptions[BootVarNum]) {

        //
        // free the local load option 
        //

        FreePool(LoadOptions[BootVarNum]);

        //
        // zero the local memory for the load options
        // 

        LoadOptions[BootVarNum] = (VOID*)0;
        LoadOptionsSize[BootVarNum] = 0;

        //
        // Get the boot option
        //
        SPrint( szTemp, sizeof(szTemp), L"Boot%04x", ((CHAR16*) BootOrder)[BootVarNum] );

#if ERASEBOOTOPT_DEBUG
        Print (L"BootXXXX = %s\n", szTemp);
#endif

        pDummy = LibGetVariableAndSize( szTemp, &VenEfi, &dummySize );

        //
        // The NVRAM variables are case sensitive.  If we were unable to 
        // find the variable, perhaps the Boot Entry string has uppercase
        // alpha characters in the hexadecimal string.  try again with
        // an uppercase string
        //
        if (pDummy == NULL && dummySize == 0) {
            SPrint( szTemp, sizeof(szTemp), L"Boot%04X", ((CHAR16*) BootOrder)[BootVarNum] );

            pDummy = LibGetVariableAndSize( szTemp, &VenEfi, &dummySize );
        }
        
        //
        // whack the nvram entry
        //

        SetVariable(
                   szTemp, 
                   &VenEfi, 
                   EFI_ATTR, 
                   0, 
                   NULL 
                   );

#if ERASEBOOTOPT_DEBUG
        Print (L"Adjusting boot order [begin]\n");
#endif

        //
        // adjust the counters for os boot options
        //
        OsBootOptionCount--;        
        BootOrderCount--;

        //
        // Shift the remaining entries in the boot order and the load options
        //

        tmpBootOrder = (CHAR16*)BootOrder;

        for (j = BootVarNum; j < BootOrderCount; j++) {
            
            //
            // adjust the boot order for all entries
            //
            tmpBootOrder[j] = tmpBootOrder[j + 1];

            //
            // only have a maximum of MAXBOOTVARS boot entries.
            // only adjust if we can.
            //
            if (j < OsBootOptionCount) {
                LoadOptions[j] = LoadOptions[j + 1]; 
                LoadOptionsSize[j] = LoadOptionsSize[j + 1];
            }

        }
        
        //
        // Set the modified boot order
        //
        SetVariable(
                   L"BootOrder", 
                   &VenEfi, 
                   EFI_ATTR, 
                   BootOrderCount * sizeof(CHAR16), 
                   BootOrder
                   );

#if ERASEBOOTOPT_DEBUG
        Print (L"Adjusting boot order [end]\n");
#endif

        return TRUE;

    }
    return FALSE;
}

BOOLEAN
EraseAllOsBootOptions(
                  )
{
    UINT32  i;
    UINT64  BootOrderSize = 0;
    BOOLEAN status;
    UINT64  maxBootCount;
#if ERASEBOOTOPT_DEBUG
    CHAR16  szInput[1024];
#endif

    //
    // Initialize EFI LoadOptions.
    //
    BootOrderSize = 0;
    BootOrderCount = 0;
    BootOrder = NULL;

    //
    // Get BootOrder.
    //
    BootOrder = LibGetVariableAndSize( L"BootOrder", &VenEfi, &BootOrderSize );
    BootOrderCount = BootOrderSize / sizeof(CHAR16);
    
    //
    // Make sure there is atleast one OS boot option
    //
    if ( BootOrder && OsBootOptionCount) {

        maxBootCount = (MAXBOOTVARS < BootOrderCount) ? MAXBOOTVARS : BootOrderCount;

        //
        // erase invidual boot options.
        //
        for ( i = 0; i < maxBootCount; i++ ) {
        
#if ERASEBOOTOPT_DEBUG
            Print (L"BootOrderCount = %x, Erasing boot option: %x\n", BootOrderCount, i);
#endif

            //
            // remove the boot entry at the head of the list
            //
            status = EraseOsBootOption(0);
            
#if ERASEBOOTOPT_DEBUG
            Input (L"Here!\n", szInput, sizeof(szInput));
            Print(L"\n");
#endif
            
            if (status == FALSE) {

                Print (L"Error: failed to erase boot entry %x\n", i);

                break;

            }
        }
    }
    
    return status;
}


BOOLEAN
PushToTop(
         IN UINT32 BootVarNum
         )
{
    UINT32 i;
    CHAR16 savBootOption;
    CHAR16* tmpBootOrder;
    UINT64 BootOrderSize = 0;

    //
    // check BootVarNum
    //
    if (MAXBOOTVARS <= BootVarNum) {
        return FALSE;
    }

    i=0;
    BootOrderSize = 0;
    BootOrder = NULL;

    //
    // Get BootOrder.
    //
    BootOrder = LibGetVariableAndSize( L"BootOrder", &VenEfi, &BootOrderSize );

    //
    // Make sure there is atleast one OS boot option
    //
    if ( BootOrder && OsBootOptionCount) {

        BootOrderCount = BootOrderSize / sizeof(CHAR16);

        //
        // Get the boot option.
        //
        tmpBootOrder = (CHAR16*)BootOrder;
        savBootOption = tmpBootOrder[BootVarNum];

        
        //
        // Now adjust the boot order
        //
        i=BootVarNum;
        while (i > 0) {
            tmpBootOrder[i] = tmpBootOrder[i-1];
            i--;
        }

        tmpBootOrder[0] = savBootOption;
        //
        // Set the changed boot order
        //
        SetVariable(
                   L"BootOrder", 
                   &VenEfi, 
                   EFI_ATTR, 
                   BootOrderCount * sizeof(CHAR16), 
                   BootOrder
                   );
        return TRUE;
    }
    return FALSE;
}

VOID
FreeBootManagerVars(
                   )
{
    UINTN i;

    for ( i=0; i<OsBootOptionCount; i++ ) {
        if ( LoadOptions[i] ) {
            FreePool( LoadOptions[i] );
        }
    }

    if ( BootOrder ) {
        FreePool( BootOrder );
    }

    //
    // zero the local memory for the load options
    // 
    ZeroMem( LoadOptions, sizeof(VOID*) * MAXBOOTVARS );
    ZeroMem( LoadOptionsSize, sizeof(UINT64) * MAXBOOTVARS );

}

BOOLEAN
CopyVar(
       IN UINT32 VarNum
       )
{
    CHAR16 i;
    BOOLEAN RetVal = FALSE;

    //
    // check to make sure we have room in our static structures
    //
    if (MAXBOOTVARS <= BootOrderCount) {
        return FALSE;
    }

    if ( VarNum < BootOrderCount ) {

        LoadOptions[BootOrderCount] = AllocateZeroPool( LoadOptionsSize[VarNum] );

        if ( LoadOptions[BootOrderCount] && LoadOptions[VarNum] ) {

            CopyMem( LoadOptions[BootOrderCount], LoadOptions[VarNum], LoadOptionsSize[VarNum] );
            LoadOptionsSize[BootOrderCount] = LoadOptionsSize[VarNum];

            BootOrder = ReallocatePool(
                                      (VOID*) BootOrder, 
                                      BootOrderCount * sizeof(CHAR16), 
                                      ( BootOrderCount + 1 ) * sizeof(CHAR16) 
                                      );

            ((CHAR16*) BootOrder)[BootOrderCount] = FindFreeBootOption();

            BootOrderCount++;
            OsBootOptionCount++;

            RetVal = SetBootManagerVar(BootOrderCount - 1);

        } 
    }
    return RetVal;
}

CHAR16
FindFreeBootOption(
                  )
{
    CHAR16 i;
    CHAR16 *BootOptionBitmap = NULL;
    UINT64 maxBootEntry;
    CHAR16 Id = 0xFFFF;

    //
    // use a bitmask to find an open spot.  by the pigeonhole
    // principle, we are guaranteed to find a spot if we 
    // look at BootOrderCount+1 entries
    //
    BootOptionBitmap = AllocateZeroPool( (BootOrderCount+1) * sizeof(CHAR16) );

    if (BootOptionBitmap) {
        for ( i=0; i<BootOrderCount; i++ ) {
            if ( ((CHAR16*)BootOrder)[i] <= BootOrderCount ) {
                BootOptionBitmap[ ((CHAR16*)BootOrder)[i] ] = 1;
            }
        }

        for ( i=0; i <= BootOrderCount; i++ ) {
            if ( BootOptionBitmap[i] == 0 ) {
                Id = i;
                break;
            }
        }

        FreePool(BootOptionBitmap);
    }

    return Id;
}

BOOLEAN
SetBootManagerVar(
                UINTN    BootVarNum
                )
{
    CHAR16  szTemp[50];
    BOOLEAN status;

    //
    // check BootVarNum
    //
    if (MAXBOOTVARS <= BootVarNum) {
        return FALSE;
    }

    status = TRUE;

    SPrint( szTemp, sizeof(szTemp), L"Boot%04x", ((CHAR16*) BootOrder)[BootVarNum] );
    
    if (LoadOptions[BootVarNum]) {
        
        SetVariable(
                   szTemp, 
                   &VenEfi, 
                   EFI_ATTR, 
                   LoadOptionsSize[BootVarNum], 
                   LoadOptions[BootVarNum] 
                   );
        
        SetVariable(
                   L"BootOrder", 
                   &VenEfi, 
                   EFI_ATTR, 
                   BootOrderCount * sizeof(CHAR16), 
                   BootOrder
                   );
    } 
    else
    {
        status = FALSE;
    }

    return status;
}

BOOLEAN
SetBootManagerVarCheck(
                UINTN    BootVarNum
                )
{
    CHAR16  szTemp[50];
    BOOLEAN status;
    VOID*   pDummy;
    UINTN   dummySize;

    //
    // check BootVarNum
    //
    if (MAXBOOTVARS <= BootVarNum) {
        return FALSE;
    }
    
    status = FALSE;

    SPrint( szTemp, sizeof(szTemp), L"Boot%04x", ((CHAR16*) BootOrder)[BootVarNum] );
    
    if (LoadOptions[BootVarNum]) {
        
        //
        // This routine expects to be writing a boot entry that is known 
        // to exist.  We need this routine since we did not track
        // if a hexadecimal string containing an alpha character was
        // uppercase or lowercase
        //
        pDummy = LibGetVariableAndSize( szTemp, &VenEfi, &dummySize );

        //
        // The NVRAM variables are case sensitive.  If we were unable to 
        // find the variable, perhaps the Boot Entry string has uppercase
        // alpha characters in the hexadecimal string.  try again with
        // an uppercase string
        //
        if (pDummy == NULL && dummySize == 0) {
            SPrint( szTemp, sizeof(szTemp), L"Boot%04X", ((CHAR16*) BootOrder)[BootVarNum] );

            pDummy = LibGetVariableAndSize( szTemp, &VenEfi, &dummySize );
        }        

        if (pDummy || dummySize) {
            //
            // the variable exists.  modify it now.
            //
            SetVariable(
                       szTemp, 
                       &VenEfi, 
                       EFI_ATTR, 
                       LoadOptionsSize[BootVarNum], 
                       LoadOptions[BootVarNum] 
                       );

            SetVariable(
                       L"BootOrder", 
                       &VenEfi, 
                       EFI_ATTR, 
                       BootOrderCount * sizeof(CHAR16), 
                       BootOrder
                       );

            status = TRUE;
        }
    } 

    return status;
}


VOID
SetBootManagerVars(
                  )
{
    UINTN   BootVarNum;
    BOOLEAN status;
    UINTN   maxBootCount;

    maxBootCount = (MAXBOOTVARS < BootOrderCount) ? MAXBOOTVARS : BootOrderCount;

    for ( BootVarNum = 0; BootVarNum < maxBootCount; BootVarNum++ ) {

        status = SetBootManagerVarCheck(BootVarNum);

        if (status == FALSE) {
            
            Print (L"ERROR: Attempt to write non-existent boot option to NVRAM!\n");
        
        }
    }
}


UINT64
GetBootOrderCount(
                 )
{
    return BootOrderCount;
}

UINT64
GetOsBootOptionsCount(
                     )
{
    return OsBootOptionCount;
}

VOID
SetEnvVar(
         IN CHAR16* szVarName,
         IN CHAR16* szVarValue,
         IN UINT32 deleteOnly
         )
/*
   deleteOnly
   TRUE     - Env var szVarName is deleted from nvr.
   FALSE    - Env var szVarName overwrites or creates
   
*/
{
    EFI_STATUS status;

    //
    // Erase the previous value
    //
    SetVariable(
               szVarName,
               &VenEfi,
               0,
               0,
               NULL
               );

    if ( !deleteOnly ) {

        //
        // Store the new value
        //
        status = SetVariable(
                            szVarName,
                            &VenEfi,
                            EFI_ATTR,
                            StrSize( szVarValue ),
                            szVarValue
                            );
    }
}

VOID
SubString(
         IN OUT char* Dest,
         IN UINT32 Start,
         IN UINT32 End,
         IN char* Src
         )
{
    UINTN i;
    UINTN j=0;

    for ( i=Start; i<End; i++ ) {
        Dest[ j++ ] = Src[ i ];
    }

    Dest[ j ] = '\0';
}

VOID
InsertString(
            IN OUT char* Dest,
            IN UINT32 Start,
            IN UINT32 End,
            IN char* InsertString
            )
{
    UINT32 i;
    UINT32 j=0;
    char first[1024];
    char last[1024];

    SubString( first, 0, Start, Dest  );
    SubString( last, End, (UINT32) StrLenA(Dest), Dest );

    StrCatA( first, InsertString );
    StrCatA( first, last );

    StrCpyA( Dest, first );
}



VOID
UtoA(
    OUT char* c,
    IN CHAR16* u
    )
{
    UINT32 i = 0;

    while ( u[i] ) {
        c[i] = u[i] & 0xFF;
        i++;
    }

    c[i] = '\0';
}


VOID
AtoU(
    OUT CHAR16* u,
    IN char*    c
    )
{
    UINT32 i = 0;

    while ( c[i] ) {
        u[i] = (CHAR16)c[i];
        i++;
    }

    u[i] = (CHAR16)'\0';
}

VOID
SetFieldFromLoadOption(
                       IN UINT32 BootVarNum,
                       IN UINT32 FieldType,
                       IN VOID* Data
                       )
{
    CHAR16  LoadIdentifier[200];
    char    OsLoadOptions[200];
    char    EfiFilePath[1024];
    char    OsLoadPath[1024];
    BOOLEAN status;
    UINT16 efiFilePathListLength = 0;
    UINT16 osLoadPathListLength  = 0;

    //
    // Make sure it is a valid OS load option
    //

    if (BootVarNum >= BootOrderCount)
        return ;
    if (BootVarNum >= MAXBOOTVARS) 
        return;
    if (LoadOptions[BootVarNum] == NULL)
        return;

    status = GetOsLoadOptionVars(
                       BootVarNum,
                       LoadIdentifier,
                       OsLoadOptions,
                       EfiFilePath,
                       OsLoadPath
                       );
    if (status == FALSE)    {
#ifdef DEBUG_PACK
        Print (L"\nSetFieldFromLoadOption: GetOsLoadOptionVars failed\n");
#endif // DEBUG_PACK
        return;
    }

    //
    // Set the field.
    //
    switch (FieldType) {
    
    case DESCRIPTION:
        StrCpy( LoadIdentifier, Data );
        break;

    case OSLOADOPTIONS:
        StrCpy( (CHAR16*)OsLoadOptions, (CHAR16*)Data );
        break;

#if 1
    case EFIFILEPATHLIST:
        efiFilePathListLength = SetFilePathFromShort( (EFI_DEVICE_PATH*) EfiFilePath, 
                                                      (CHAR16*) Data );
        break;

    case OSFILEPATHLIST: 
        {
        PFILE_PATH          pFilePath;
        
        pFilePath = (FILE_PATH*)OsLoadPath;
        osLoadPathListLength = SetFilePathFromShort( (EFI_DEVICE_PATH*) pFilePath->FilePath, 
                                                     (CHAR16*) Data );
        if ( osLoadPathListLength ) {
            osLoadPathListLength += (UINT16) FIELD_OFFSET( FILE_PATH, FilePath );
        }
        }
        break;
#endif

    default:
        break;

    }

    //
    // Pack the new parameters into the the current load option 
    //

    PackLoadOption(  BootVarNum,
                     LoadIdentifier,
                     (CHAR16*)OsLoadOptions,
                     EfiFilePath,
                     efiFilePathListLength,
                     OsLoadPath,
                     osLoadPathListLength
                     );

    //
    // save the new load option into NVRAM
    //

    SetBootManagerVarCheck(BootVarNum);

}

VOID
GetFilePathShort(
                EFI_DEVICE_PATH *FilePath,
                CHAR16 *FilePathShort
                )
{
    UINT32 i, j, End;
    EFI_DEVICE_PATH *n = FilePath;

    //
    // Advance to FilePath node.
    //
    while (( n->Type    != END_DEVICE_PATH_TYPE           ) &&
           ( n->SubType != END_ENTIRE_DEVICE_PATH_SUBTYPE ) ) {

        if (( n->Type    == MEDIA_DEVICE_PATH ) &&
            ( n->SubType == MEDIA_FILEPATH_DP )) {

            j = 0;
            End = DevicePathNodeLength(n);

            for ( i=sizeof(EFI_DEVICE_PATH); i<End; i++ ) {
                ((char*) FilePathShort)[j++] = ( (char*) n)[i];
            }

            break;
        }

        n = NextDevicePathNode(n);
    }
}


VOID
GetDiskGuidFromPath( 
    EFI_DEVICE_PATH *FilePath, 
    EFI_GUID *DiskGuid
    )
{
    UINT32 i, j, End;
    EFI_DEVICE_PATH *n = FilePath;
    HARDDRIVE_DEVICE_PATH *harddriveDp;

    //
    // Advance to FilePath node.
    //
    while (( n->Type    != END_DEVICE_PATH_TYPE           ) &&
           ( n->SubType != END_ENTIRE_DEVICE_PATH_SUBTYPE ) ) {

        if (( n->Type    == MEDIA_DEVICE_PATH ) &&
            ( n->SubType == MEDIA_HARDDRIVE_DP )) {
            harddriveDp = (HARDDRIVE_DEVICE_PATH *)n;
            CopyMem( DiskGuid, &harddriveDp->Signature, sizeof(harddriveDp->Signature) );

            break;
        }

        n = NextDevicePathNode(n);
    }
}

UINT16 // new FilePathListLength if updated. 0 otherwise.
SetFilePathFromShort(
                    EFI_DEVICE_PATH *FilePath,
                    CHAR16* FilePathShort
                    )
{
    UINT32 i, j, End;
    EFI_DEVICE_PATH *n = FilePath;
    UINT64 DevicePathSize;
    UINT16 length = 0;

    //
    // Advance to FilePath node.
    //
    while (( n->Type    != END_DEVICE_PATH_TYPE           ) &&
           ( n->SubType != END_ENTIRE_DEVICE_PATH_SUBTYPE ) ) {

        if (( n->Type    == MEDIA_DEVICE_PATH ) &&
            ( n->SubType == MEDIA_FILEPATH_DP )) {

#if DEBUG_PACK
            Print (L"SetFilePathFromShort: Entry found...\n");
#endif // DEBUG_PACK

            j = 0;
            End = DevicePathNodeLength(n);

            //
            // Set the new file path
            //
            DevicePathSize = GetDevPathSize(n);
            for ( i=sizeof(EFI_DEVICE_PATH); i<DevicePathSize; i++ ) {
                ((char*) n)[i] = '\0';
            }

            j=sizeof(EFI_DEVICE_PATH);

            for ( i=0; i<StrSize(FilePathShort); i++ ) {
                ((char*)n)[j++] = ((char*)FilePathShort)[i];
            }

            SetDevicePathNodeLength( n, StrSize(FilePathShort) + sizeof(EFI_DEVICE_PATH) );

            n = NextDevicePathNode(n);
            SetDevicePathEndNode(n);
            n = NextDevicePathNode(n);
            length = (UINT16)((ULONG_PTR)n - (ULONG_PTR)FilePath);
            break;
        }

        n = NextDevicePathNode(n);
    }
#if DEBUG_PACK
    if (length == 0) Print (L"SetFilePathFromShort: Entry _NOT_ updated...\n");
#endif // DEBUG_PACK
    return( length );
}

VOID
SetDiskGuidInPath( 
    EFI_DEVICE_PATH *FilePath, 
    EFI_GUID *DiskGuid
    )
{
    UINT32 i, j, End;
    EFI_DEVICE_PATH *n = FilePath;
    HARDDRIVE_DEVICE_PATH *harddriveDp;

    //
    // Advance to FilePath node.
    //
    while (( n->Type    != END_DEVICE_PATH_TYPE           ) &&
           ( n->SubType != END_ENTIRE_DEVICE_PATH_SUBTYPE ) ) {

        if (( n->Type    == MEDIA_DEVICE_PATH ) &&
            ( n->SubType == MEDIA_FILEPATH_DP )) {
            harddriveDp = (HARDDRIVE_DEVICE_PATH *)n;
            CopyMem( &harddriveDp->Signature, DiskGuid, sizeof(harddriveDp->Signature) );

            break;
        }

        n = NextDevicePathNode(n);
    }
}


char*
GetAlignedELOFilePath(
                        char*   elo
    )
{
    UINTN               abufSize;
    char*               abuf;
    PEFI_LOAD_OPTION    pElo;
    
    pElo = (EFI_LOAD_OPTION*)elo;

    abufSize = pElo->FilePathListLength;

    abuf = AllocatePool(abufSize);

    CopyMem(abuf,
            elo + 
            FIELD_OFFSET(EFI_LOAD_OPTION, Description) + 
            StrSize(pElo->Description),  
            abufSize
           );

    return abuf;
}

char*
GetAlignedOptionalData(
                char*   elo,
                UINT64  eloSize,
                UINT64* dataSize
                )
{
    UINTN               abufSize;
    char*               abuf;
    PEFI_LOAD_OPTION    pElo;
    UINTN               offset;
    
    pElo = (EFI_LOAD_OPTION*)elo;

    offset = FIELD_OFFSET(EFI_LOAD_OPTION, Description) + 
                StrSize(pElo->Description) +
                pElo->FilePathListLength;

    abufSize = eloSize - offset;
    
    abuf = AllocatePool(abufSize);

    CopyMem(abuf,
            elo + offset,
            abufSize
            );

    *dataSize = abufSize;

    return abuf;
}

char*
GetAlignedOsOptions(
                char*   elo,
                UINT64  eloSize
    )
{
    UINT64      dummy;
    char*       abuf;

    abuf = GetAlignedOptionalData(elo,
                                  eloSize,
                                  &dummy
                                 );

    return abuf;
}

char*
GetAlignedOsLoadPath(
                IN  char*       osOptions,
                OUT UINTN*      osLoadPathSize
    )
//
// we need to align the FilePath structure because the load options are
// variable in length, so the FilePath structure may not be aligned
//
{
    UINTN               abufSize;
    char*               abuf;
    PWINDOWS_OS_OPTIONS pOsOptions;

    pOsOptions = (WINDOWS_OS_OPTIONS*)osOptions;

    abufSize = pOsOptions->Length - 
                FIELD_OFFSET(WINDOWS_OS_OPTIONS, OsLoadOptions) -
                StrSize(pOsOptions->OsLoadOptions);

    abuf = AllocatePool(abufSize);

    CopyMem(abuf, 
            &osOptions[pOsOptions->OsLoadPathOffset], 
            abufSize
            );

    *osLoadPathSize = abufSize;

    return abuf;
}

VOID
DisplayLoadPath(
                char*           osLoadPath
                )
{
    PFILE_PATH          pFilePath;
    
    pFilePath = (FILE_PATH*)osLoadPath;
    
    Print (L"osOptions->FILE_PATH->Version = %x\n", pFilePath->Version);
    Print (L"osOptions->FILE_PATH->Length = %x\n", pFilePath->Length);
    Print (L"osOptions->FILE_PATH->Type = %x\n", pFilePath->Type);
    
    if (pFilePath->Type == FILE_PATH_TYPE_EFI) {

        CHAR16      FilePathShort[200];

        GetFilePathShort(
                        (EFI_DEVICE_PATH *)pFilePath->FilePath,
                        FilePathShort
                        );

        Print (L"osOptions->FILE_PATH->FilePath(EFI:DP:Short) = %s\n", FilePathShort);

    }
}

VOID
DisplayOsOptions(
                char*           osOptions
                )
{
    PWINDOWS_OS_OPTIONS pOsOptions;
    CHAR16              wideSig[256];    
    char*               aOsLoadPath;
    UINTN               aOsLoadPathSize;

    pOsOptions = (WINDOWS_OS_OPTIONS*)osOptions;

    Print (L">>>>\n");

    //
    // display the attributes
    //

    AtoU(wideSig, pOsOptions->Signature);

    Print (L"osOptions->Signature = %s\n",  wideSig);
    Print (L"osOptions->Version = %x\n", pOsOptions->Version);
    Print (L"osOptions->Length = %x\n", pOsOptions->Length);
    Print (L"osOptions->OsLoadPathOffset = %x\n", pOsOptions->OsLoadPathOffset);

    // display the os load options

    Print (L"osOptions->OsLoadOptions = %s\n", pOsOptions->OsLoadOptions);

    //
    // display the FILE PATH
    //
    
    //
    // we need to align the FilePath structure because the load options are
    // variable in length, so the FilePath structure may not be aligned
    //
    aOsLoadPath = GetAlignedOsLoadPath(osOptions, &aOsLoadPathSize);

    DisplayLoadPath(aOsLoadPath);   

    FreePool(aOsLoadPath);

    Print (L"<<<<\n");

}

VOID
DisplayELO(
    char*       elo,
    UINT64      eloSize
    )
{
    PEFI_LOAD_OPTION        pElo;
#if 0
    UINT64                  eloSize;
#endif    
    CHAR16                  FilePathShort[200];
    char*                   aOsOptions;

    pElo = (EFI_LOAD_OPTION*)elo;

    Print (L"elo->Attributes = %x\n", pElo->Attributes);
    Print (L"elo->FilePathListLength = %x\n", pElo->FilePathListLength);
    Print (L"elo->Description = %s\n", pElo->Description);

    GetFilePathShort(
                    (EFI_DEVICE_PATH *)&elo[FIELD_OFFSET(EFI_LOAD_OPTION, Description) + StrSize(pElo->Description)],
                    FilePathShort
                    );
    Print (L"elo->FilePath(EFI:DP:SHORT) = %s\n", FilePathShort);

#if 0
    eloSize = FIELD_OFFSET(EFI_LOAD_OPTION, Description) + StrSize(pElo->Description) + pElo->FilePathListLength;
    DisplayOsOptions(&elo[eloSize]);
#else

    aOsOptions = GetAlignedOsOptions(
        elo, 
        eloSize
        );

    DisplayOsOptions(aOsOptions);
    
    FreePool(aOsOptions);

#endif

}

VOID
BuildNewOsOptions(
                 IN  CHAR16*                 osLoadOptions,
                 IN  char*                   osLoadPath,
                 OUT char**                  osOptions
                 )
//
//
// Note:    osLoadPath must be aligned
// 
{
    char*                       newOsOptions;
    PWINDOWS_OS_OPTIONS         pNewOsOptions;
    UINT32                      osLoadOptionsLength;
    UINT32                      osOptionsLength;
    PFILE_PATH                  pOsLoadPath;

    //
    // NOTE: aligning the FILE_PATH structure (osLoadPath) works
    //       by aligning the osLoadOptionsLength because the
    //       WINDOWS_OS_OPTIONS structure has a UINT32 variable
    //       before the OsLoadOptions.  If anything changes above
    //       the OsLoadOptions in the WINDOWS_OS_OPTIONS structure
    //       the alignment method may have to change in this structure.
    //

    //
    //
    // determine the size of the os load options (UNICODE) string
    //

    osLoadOptionsLength = (UINT32)StrSize(osLoadOptions);
    osLoadOptionsLength = ALIGN_UP(osLoadOptionsLength, UINT32);

#if DEBUG_PACK
    Print (L"osLoadOptionsLength = %x\n", osLoadOptionsLength);
#endif

    pOsLoadPath = (FILE_PATH*)osLoadPath;

#if DEBUG_PACK
    Print (L"pOsLoadPath->Length = %x\n", pOsLoadPath->Length);
#endif

    //
    // determine the size of the new WINDOWS_OS_OPTIONS structure
    //

    osOptionsLength = FIELD_OFFSET(WINDOWS_OS_OPTIONS, OsLoadOptions) + osLoadOptionsLength + pOsLoadPath->Length; 
#if DEBUG_PACK
    Print (L"osOptionsLength = %x\n", osOptionsLength);
#endif

    //
    // Allocate memory for the WINDOWS_OS_OPTIONS
    //

    newOsOptions = AllocatePool(osOptionsLength);

    ASSERT(newOsOptions != NULL);

    pNewOsOptions = (WINDOWS_OS_OPTIONS*)newOsOptions;

    //
    // populate the new os options
    // 

    StrCpyA((char *)pNewOsOptions->Signature, WINDOWS_OS_OPTIONS_SIGNATURE);
    pNewOsOptions->Version = WINDOWS_OS_OPTIONS_VERSION;
    pNewOsOptions->Length = (UINT32)osOptionsLength;
    pNewOsOptions->OsLoadPathOffset = FIELD_OFFSET(WINDOWS_OS_OPTIONS, OsLoadOptions) + osLoadOptionsLength;
    StrCpy(pNewOsOptions->OsLoadOptions, osLoadOptions);
    CopyMem( &newOsOptions[pNewOsOptions->OsLoadPathOffset], osLoadPath, pOsLoadPath->Length );
    
    *osOptions = newOsOptions;
}

VOID
PackLoadOption(
                 IN UINT32   BootVarNum,
                 IN CHAR16*  LoadIdentifier,
                 IN CHAR16*  OsLoadOptions,
                 IN char*    EfiFilePath,
                 IN UINT16   EfiFilePathListLength,   // 0 if not updated
                 IN char*    OsLoadPath,
                 IN UINT16   OsLoadPathListLength     // 0 if not updated
                 )
/*
    PackLoadOption
     
    Purpose:   To construct an EFI_LOAD_OPTION structure using user arguments
                and load the structure into into BootXXXX, where XXXX = BootVarNum.
                See EFI spec, ch. 17
     
     Args:
     
        BootVarNum      The boot option being written/modified
        
 
*/
{
    PEFI_LOAD_OPTION        pOldElo;
    PEFI_LOAD_OPTION        pElo;
    char*                   elo;
    char*                   oldElo;
    UINT64                  oldEloSize;
    UINT64                  eloSize;
    UINT8*                  oldEloFilePath;
    UINT64                  TempEfiFilePathListSize;
    char*                   aFilePath;
    UINT16                  filePathListLength;
    UINT16                  loadPathListLength;

#if DEBUG_PACK
    
    CHAR16                  szInput[1024];

    Print (L"BootVarNum = %x\n", BootVarNum);
    Print (L"LoadIdentifier = %s\n", LoadIdentifier);
    Print (L"OsLoadOptions = %s\n", OsLoadOptions);

    Input (L"Here! [Pack begin] \n", szInput, sizeof(szInput));
    Print(L"\n");

#endif

    // 
    // The following code assumes EfiFilePath and OsLoadPath are pointer-aligned
    // if the corresponding length exposes an update by the caller.
    // Checking and failing at the function entry avoids unneeded memory allocations.
    //

    if ( EfiFilePathListLength && !POINTER_IS_ALIGNED(EfiFilePath, sizeof(void *)))  {
        ASSERT( POINTER_IS_ALIGNED(EfiFilePath, sizeof(void *)) );
        Print (L"PackLoadOption: EfiFilePath unaligned.\n");
        return;
    }
    if ( OsLoadPathListLength && !POINTER_IS_ALIGNED(OsLoadPath, sizeof(void *)))  {
        ASSERT( POINTER_IS_ALIGNED(OsLoadPath, sizeof(void *)) );
        Print (L"PackLoadOption: OsLoadPath unaligned.\n");
        return;
    }
    
    oldElo = LoadOptions[BootVarNum];
    oldEloSize = LoadOptionsSize[BootVarNum];

#if DEBUG_PACK

    DisplayELO(oldElo, oldEloSize);
    Input (L"Here! [Pack begin] \n", szInput, sizeof(szInput));
    Print(L"\n");

#endif

    //
    // allocate the elo structure with maximal amount of memory allowed for
    // an EFI_LOAD_OPTION
    //
    elo = AllocatePool(MAXBOOTVARSIZE);
    if (elo == NULL) {
        Print (L"PackLoadOption: elo allocation failed. size=%d\n", MAXBOOTVARSIZE);
        return;
    }

    pElo = (EFI_LOAD_OPTION*)elo;
    pOldElo = (EFI_LOAD_OPTION*)oldElo;

    //
    // Efi Attribute.
    //
    eloSize = sizeof(pElo->Attributes);
    pElo->Attributes = pOldElo->Attributes;

    //
    // FilePathListLength
    //
    eloSize += sizeof(pElo->FilePathListLength);
    filePathListLength = EfiFilePathListLength ? EfiFilePathListLength :  
                                                 pOldElo->FilePathListLength;
    pElo->FilePathListLength = filePathListLength;

    //
    // Description.
    //
    StrCpy( pElo->Description, LoadIdentifier );
    eloSize += StrSize(LoadIdentifier);

    if ( EfiFilePathListLength == 0 )  {
        //
        // copy the FilePath from the old/existing ELO structure
        //
        // Note: we don't actually need an aligned filepath block for this
        //      copy, but there may come a time when we want to modify
        //      the filepath, which will require an aligned block.
        //
    
        aFilePath = GetAlignedELOFilePath(oldElo);
    }
    else  {
        // already checked: ASSERT( POINTER_IS_ALIGNED(EfiFilePath, sizeof(void *)) );
        aFilePath = EfiFilePath; 
    }
    CopyMem( &elo[eloSize],
              aFilePath,
              filePathListLength
           );
    eloSize += filePathListLength;
    if ( EfiFilePathListLength == 0 )  {
        FreePool(aFilePath);
    }

#if DEBUG_PACK
    
    Print (L"eloSize = %x\n", eloSize);
    Input (L"Here! \n", szInput, sizeof(szInput));
    Print(L"\n");

#endif

    //
    // add or modify the boot option
    //
    if ( BootVarNum == -1 ) {

        Print(L"Adding currently disabled\n");

    } else {
        
        char*                   osOptions;
        char*                   aOsLoadPath = NULL;
        char*                   aOldOsOptions;
        PWINDOWS_OS_OPTIONS     pOldOsOptions;
        PWINDOWS_OS_OPTIONS     pOsOptions;
        UINTN                   aOsLoadPathSize;

        //
        // OptionalData.
        //
        // For a Windows OS boot option, the OptionalData field in the EFI_LOAD_OPTION
        // structure is a WINDOWS_OS_OPTION structure.

        //
        // get the WINDOWS_OS_OPTIONS from the old/existing boot entry
        //

        aOldOsOptions = GetAlignedOsOptions(oldElo, oldEloSize);
        pOldOsOptions = (WINDOWS_OS_OPTIONS*)aOldOsOptions;

        //
        // Get the LoadPath from the old/existing WINDOWS_OS_OPTIONS structure
        //
        // we need to align the FilePath structure because the load options are
        // variable in length, so the FilePath structure may not be aligned
        //
        if ( OsLoadPathListLength == 0 ) { 
           aOsLoadPath = GetAlignedOsLoadPath(aOldOsOptions, &aOsLoadPathSize);
        }
        else  {
           FILE_PATH *filePath;
           // already checked: ASSERT( POINTER_IS_ALIGNED(OsLoadPath, sizeof(void *)) );
           aOsLoadPath = OsLoadPath;
           filePath = (FILE_PATH *)aOsLoadPath;
           filePath->Length = OsLoadPathListLength;
        }

        FreePool(aOldOsOptions);
                
        //
        // Construct a new WINDOWS_OS_STRUCTURE with the new values
        //

        BuildNewOsOptions(
                         OsLoadOptions,
                         aOsLoadPath,
                         &osOptions
                         );
        
        if ( OsLoadPathListLength == 0 ) { 
            FreePool(aOsLoadPath);
        }
        
#if DEBUG_PACK
        
        Input (L"build\n", szInput, sizeof(szInput) );
        Print(L"\n");

        DisplayOsOptions(osOptions);
        Input (L"elo freed\n", szInput, sizeof(szInput) );
        Print(L"\n");

#endif

        pOsOptions = (WINDOWS_OS_OPTIONS*)osOptions;

        //
        // Copy the new WINDOWS_OS_OPTIONS structure into the new EFI_LOAD_OPTION structure
        //
        
        CopyMem( &elo[eloSize], osOptions, pOsOptions->Length);

        eloSize += pOsOptions->Length;
        
#if DEBUG_PACK
        
        Print (L"osOptions->Length = %x\n", pOsOptions->Length);
        Print (L"eloSize = %x\n", eloSize);
        
#endif

        FreePool(osOptions);

        //
        // Modify current boot options.
        //
        LoadOptions[BootVarNum] = ReallocatePool( LoadOptions[BootVarNum], LoadOptionsSize[BootVarNum], eloSize );
        LoadOptionsSize[BootVarNum] = eloSize;

        CopyMem( LoadOptions[BootVarNum], elo, eloSize );
    }

    FreePool(elo);

    ASSERT(eloSize < MAXBOOTVARSIZE);

#if DEBUG_PACK
    Input (L"elo freed\n", szInput, sizeof(szInput) );
    Print(L"\n");
    Print (L">>\n");
    DisplayELO((char*)LoadOptions[BootVarNum], LoadOptionsSize[BootVarNum]);
    Print (L"<<\n");
    Input (L"pack done\n", szInput, sizeof(szInput) );
    Print(L"\n");
#endif
}

EFI_STATUS
AppendEntryToBootOrder(
    UINT16 BootNumber
    )
{
    EFI_STATUS  status;
    UINT64      oldBootOrderSize;
    UINT64      newBootOrderSize;
    VOID*       newBootOrder;
    VOID*       oldBootOrder;

    newBootOrder = NULL;
    oldBootOrder = NULL;

    //
    // get the existing boot order array
    //
    oldBootOrder = LibGetVariableAndSize( L"BootOrder", &VenEfi, &oldBootOrderSize );
    if ((!oldBootOrder) && 
        (oldBootOrderSize != 0)
        ) {
        Print(L"\nError: Failed to get old boot order array.\n");
        status = EFI_OUT_OF_RESOURCES;
        goto Done;
    }

    //
    // allocate the new boot order array
    //
    newBootOrderSize = oldBootOrderSize + sizeof(BootNumber);
    newBootOrder = AllocatePool( newBootOrderSize );
    if (! newBootOrder) {
        Print(L"\nError: Failed to allocate new boot order array.\n");
        status = EFI_OUT_OF_RESOURCES;
        goto Done;
    }

    //
    // append the new boot entry to the bottom of the list
    //
    CopyMem(
           (CHAR8*)newBootOrder, 
           oldBootOrder,
           oldBootOrderSize
           );
    CopyMem(
           (CHAR8*)newBootOrder + oldBootOrderSize, 
           &BootNumber, 
           sizeof(BootNumber) );

    status = SetVariable(
                        L"BootOrder",
                        &VenEfi,
                        EFI_ATTR,
                        newBootOrderSize,
                        newBootOrder
                        );

Done:

    if (oldBootOrder) {
        FreePool( oldBootOrder );
    }
    
    if (newBootOrder) {
        FreePool(newBootOrder);
    }

    return status;

}

EFI_STATUS
WritePackedDataToNvr(
                    UINT16 BootNumber,
                    VOID  *BootOption,
                    UINT32 BootSize
                    )
{
    EFI_STATUS  status;
    CHAR16      VariableName[10];

    //
    // Don't attempt to write the BootEntry if it has no size.
    // 
    if (BootSize == 0) {
        return EFI_SUCCESS;
    }


    SPrint( VariableName, sizeof(VariableName), L"Boot%04x", BootNumber );
    
    status = SetVariable(
                        VariableName,
                        &VenEfi,
                        EFI_ATTR,
                        BootSize,
                        BootOption
                        );
    if (status == EFI_SUCCESS) {
        
        status = AppendEntryToBootOrder(BootNumber);
        if (status != EFI_SUCCESS) {
        
            Print(L"\nError: Failed to append new boot entry to boot order array\n");

            goto Done;

        }

    } else {

        Print(L"\nError: Failed to set new boot entry variable\n");

        goto Done;
    }

    //
    // repopulate the local info about boot entries
    //
    FreeBootManagerVars();
    GetBootManagerVars();

Done:

    return status;

}

#if DEBUG_PACK
VOID
DisplayELOFromLoadOption(
    IN UINT32 OptionNum
    )
{
    char*               elo;
    PEFI_LOAD_OPTION    pElo;

    //
    // Make sure it is a valid OS load option
    //
    if (OptionNum >= BootOrderCount) {
        return;
    }
    if (OptionNum >= MAXBOOTVARS) {
        return;
    }
    if (LoadOptions[OptionNum] == NULL) {
        return;
    }

    pElo = (EFI_LOAD_OPTION*)LoadOptions[OptionNum];
    elo  = (char*)LoadOptions[OptionNum];

    DisplayELO(elo, LoadOptionsSize[OptionNum]);

}
#endif

VOID
GetFieldFromLoadOption(
                      IN UINT32 OptionNum,
                      IN UINT32 FieldType,
                      OUT VOID* Data,
                      OUT UINT64* DataSize
                      )
{
    char*               elo;
    PEFI_LOAD_OPTION    pElo;

    //
    // Make sure it is a valid OS load option
    //
    if (OptionNum >= BootOrderCount) {
        return;
    }
    if (OptionNum >= MAXBOOTVARS) {
        return;
    }
    if (LoadOptions[OptionNum] == NULL) {
        *DataSize = 0;
        return;
    }

    pElo = (EFI_LOAD_OPTION*)LoadOptions[OptionNum];
    elo  = (char*)LoadOptions[OptionNum];

    switch ( FieldType ) {
    
    case ATTRIBUTE: {

            *((UINT32*) Data) = pElo->Attributes;
            *DataSize = sizeof(UINT32);

            break;
        }
    case FILEPATHLISTLENGTH: {

            *((UINT16*) Data) = pElo->FilePathListLength;
            *DataSize = sizeof(UINT16);

            break;
        }
    case DESCRIPTION: {

            StrCpy((CHAR16*)Data, pElo->Description);
            *DataSize = StrSize(pElo->Description);

            break;
        }
    case EFIFILEPATHLIST: {

            char*       aFilePath;

            aFilePath = GetAlignedELOFilePath(elo);

            CopyMem(Data, 
                    aFilePath,
                    pElo->FilePathListLength
                   );

            FreePool(aFilePath);

            *DataSize = pElo->FilePathListLength;

            break;
        }
    case OPTIONALDATA: {

            char*           aOptionalData;
            UINT64          eloSize;

            eloSize = LoadOptionsSize[OptionNum];

            aOptionalData = GetAlignedOptionalData(elo, 
                                                   eloSize,
                                                   DataSize
                                                   );

            CopyMem(Data, aOptionalData, *DataSize);

            FreePool(aOptionalData);

            break;

        }
    default:

        *DataSize = 0;

        break;
    }
}

BOOLEAN
GetLoadIdentifier(
                 IN UINT32 BootVarNum,
                 OUT CHAR16* LoadIdentifier
                 )
{
    UINT64 DataSize = 0;

    GetFieldFromLoadOption(
                          BootVarNum,
                          DESCRIPTION,
                          LoadIdentifier,
                          &DataSize
                          );
    if (!DataSize)
        return FALSE;
    return TRUE;
}

VOID
GetEfiOsLoaderFilePath(
           IN UINT32 BootVarNum,
           OUT char* FilePath
           )
{
    UINT64 DataSize = 0;

    GetFieldFromLoadOption(
                          BootVarNum,
                          EFIFILEPATHLIST,
                          FilePath,
                          &DataSize
                          );
}

BOOLEAN
GetOsLoadOptionVars(
                   IN      UINT32 BootVarNum,
                   OUT     CHAR16* LoadIdentifier,
                   OUT     char* OsLoadOptions,
                   OUT     char* EfiFilePath,
                   OUT     char* OsLoadPath
                   )
{
    if (BootVarNum >= BootOrderCount)
        return FALSE;
    if (BootVarNum >= MAXBOOTVARS) {
        return FALSE;
    }
    if (!LoadOptions[BootVarNum])
        return FALSE;


    GetLoadIdentifier( BootVarNum, LoadIdentifier );

    GetOptionalDataValue( BootVarNum, OSLOADOPTIONS,    OsLoadOptions );
    
    GetEfiOsLoaderFilePath( BootVarNum, EfiFilePath );

    GetOptionalDataValue( BootVarNum, OSLOADPATH, OsLoadPath);

    return TRUE;
}

VOID
GetOptionalDataValue(
                    IN UINT32 BootVarNum,
                    IN UINT32 Selection,
                    OUT char* OptionalDataValue
                    )
{
    char                osOptions[MAXBOOTVARSIZE];
    UINT64              osOptionsSize;
    PWINDOWS_OS_OPTIONS pOsOptions;

    if (BootVarNum < MAXBOOTVARS) {

        GetFieldFromLoadOption(
                              BootVarNum,
                              OPTIONALDATA,
                              osOptions,
                              &osOptionsSize
                              );

        pOsOptions = (PWINDOWS_OS_OPTIONS)osOptions;

        switch (Selection) {
        case OSLOADOPTIONS: {

                StrCpy( (CHAR16*)OptionalDataValue, pOsOptions->OsLoadOptions );

                break;
            }

        case OSLOADPATH: {
            
                char*               aOsLoadPath;
                UINTN               aOsLoadPathSize;

                aOsLoadPath = GetAlignedOsLoadPath(osOptions, &aOsLoadPathSize);

                CopyMem(OptionalDataValue,
                        aOsLoadPath,
                        aOsLoadPathSize
                        );

                FreePool(aOsLoadPath);

                break;
            }

        default: {

                break;

            }
        }
    }
}

UINTN
GetDevPathSize(
              IN EFI_DEVICE_PATH *DevPath
              )
{
    EFI_DEVICE_PATH *Start;

ASSERT(DevPath->Type != END_DEVICE_PATH_TYPE);

    //
    // Search for the end of the device path structure
    //
    Start = DevPath;
    do  {
        DevPath = NextDevicePathNode(DevPath);
    } while (DevPath->Type != END_DEVICE_PATH_TYPE);

    //
    // Compute the size
    //
    return(UINTN) ((UINT64) DevPath - (UINT64) Start);
}

UINT32
GetPartitions(
             )
{

    EFI_HANDLE EspHandles[100],FSPath;
    UINT64 HandleArraySize = 100 * sizeof(EFI_HANDLE);
    UINT64 CachedDevicePaths[100];
    UINTN i, j;
    UINTN CachedDevicePathsCount;
    UINT64 SystemPartitionPathSize;
    EFI_DEVICE_PATH *dp;
    EFI_STATUS Status;
    UINT32 PartitionCount;
    char AlignedNode[1024];

    //
    // Get all handles that supports the block I/O protocol.
    //
    ZeroMem( EspHandles, HandleArraySize );

    Status = LocateHandle (
                          ByProtocol,
                          &EfiESPProtocol,
                          0,
                          (UINTN *) &HandleArraySize,
                          EspHandles
                          );

    //
    // Cache all of the EFI Device Paths.
    //
    for (i = 0; EspHandles[i] != 0; i++) {

        Status = HandleProtocol (
                                EspHandles[i],
                                &DevicePathProtocol,
                                &( (EFI_DEVICE_PATH *) CachedDevicePaths[i] )
                                );
    }

    //
    // Save the number of cached Device Paths.
    //
    CachedDevicePathsCount = i;
    PartitionCount = 0;

    //
    // Find the first partition on the first hard drive
    // partition. That is our SystemPartition.
    //
    for ( i=0; i<CachedDevicePathsCount; i++ ) {

        dp = (EFI_DEVICE_PATH*) CachedDevicePaths[i];

        while (( DevicePathType(dp)    != END_DEVICE_PATH_TYPE ) &&
               ( DevicePathSubType(dp) != END_ENTIRE_DEVICE_PATH_SUBTYPE )) {

            if (( DevicePathType(dp)    == MEDIA_DEVICE_PATH ) &&
                ( DevicePathSubType(dp) == MEDIA_HARDDRIVE_DP )) {
                CopyMem( AlignedNode, dp, DevicePathNodeLength(dp) );

                HandleProtocol (EspHandles[i],&FileSystemProtocol,&FSPath);
                if ( FSPath != NULL) {
                    PartitionCount++;
                }
            }
            dp = NextDevicePathNode(dp);
        }
    }

    return PartitionCount;
}

EFI_HANDLE
GetDeviceHandleForPartition(
                           )
{
    EFI_HANDLE EspHandles[100],FSPath;
    UINT64 HandleArraySize = 100 * sizeof(EFI_HANDLE);
    UINT64 CachedDevicePaths[100];
    UINTN i, j;
    UINTN CachedDevicePathsCount;
    UINT64 SystemPartitionPathSize;
    EFI_DEVICE_PATH *dp;
    EFI_STATUS Status;
    char AlignedNode[1024];

    //
    // Get all handles that supports the block I/O protocol.
    //
    ZeroMem( EspHandles, HandleArraySize );

    Status = LocateHandle (
                          ByProtocol,
                          &EfiESPProtocol,
                          0,
                          (UINTN *) &HandleArraySize,
                          EspHandles
                          );

    //
    // Cache all of the EFI Device Paths.
    //
    for (i = 0; EspHandles[i] != 0; i++) {

        Status = HandleProtocol (
                                EspHandles[i],
                                &DevicePathProtocol,
                                &( (EFI_DEVICE_PATH *) CachedDevicePaths[i] )
                                );
    }

    //
    // Save the number of cached Device Paths.
    //
    CachedDevicePathsCount = i;

    //
    // Find the first ESP partition on the first hard drive
    // partition. That is our SystemPartition.
    //
    for ( i=0; i<CachedDevicePathsCount; i++ ) {

        dp = (EFI_DEVICE_PATH*) CachedDevicePaths[i];

        while (( DevicePathType(dp)    != END_DEVICE_PATH_TYPE ) &&
               ( DevicePathSubType(dp) != END_ENTIRE_DEVICE_PATH_SUBTYPE )) {

            if (( DevicePathType(dp)    == MEDIA_DEVICE_PATH ) &&
                ( DevicePathSubType(dp) == MEDIA_HARDDRIVE_DP )) {
                CopyMem( AlignedNode, dp, DevicePathNodeLength(dp) );

                HandleProtocol (EspHandles[i],&FileSystemProtocol,&FSPath);
                if ( FSPath != NULL) {
                    //
                    // Found the correct device path partition. 
                    // Return the device handle.
                    //
                    return( EspHandles[i] );

                }
            }

            dp = NextDevicePathNode(dp);
        }
    }

    return NULL;
}

/*
** BUGBUG: These functions need to be eventually placed in lib\str.c
*/
INTN
RUNTIMEFUNCTION
StrCmpA (
        IN CHAR8   *s1,
        IN CHAR8   *s2
        )
/*  compare strings */
{
    while (*s1) {
        if (*s1 != *s2) {
            break;
        }

        s1 += 1;
        s2 += 1;
    }

    return *s1 - *s2;
}

VOID
RUNTIMEFUNCTION
StrCpyA (
        IN CHAR8   *Dest,
        IN CHAR8   *Src
        )
/*  copy strings */
{
    while (*Src) {
        *(Dest++) = *(Src++);
    }
    *Dest = 0;
}

VOID
RUNTIMEFUNCTION
StrCatA (
        IN CHAR8   *Dest,
        IN CHAR8   *Src
        )
{   
    StrCpyA(Dest+StrLenA(Dest), Src);
}

UINTN
RUNTIMEFUNCTION
StrLenA (
        IN CHAR8   *s1
        )
/*  string length */
{
    UINTN        len;

    for (len=0; *s1; s1+=1, len+=1) ;
    return len;
}

UINTN
RUNTIMEFUNCTION
StrSizeA (
         IN CHAR8   *s1
         )
/*  string size */
{
    UINTN        len;

    for (len=0; *s1; s1+=1, len+=1) ;
    return(len + 1) * sizeof(CHAR8);
}